package com.hjt.gulimall.search.thread;


import java.util.concurrent.*;

/**
 * @author:97007
 * @date:2021/9/27 13:32
 */
public class ThreadTest {

    // 自定义线程池
    public static ThreadPoolExecutor executor = new ThreadPoolExecutor(5,
                                                                    100,
                                                                        60,
                                                                        TimeUnit.SECONDS,
                                                                    new LinkedBlockingQueue<>(20),
                                                                    Executors.defaultThreadFactory(),
                                                                    new ThreadPoolExecutor.AbortPolicy());

    public static void main(String[] args) throws ExecutionException, InterruptedException {
//        // 创建异步对象的四种静态方法
//        // 1.异步执行无返回值
//        CompletableFuture<Void> future1 = CompletableFuture.runAsync(()->{
//            System.out.println("111");
//        },executor);
//
//        // 2.异步执行有返回值
//        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("计算ing");
//            return 10/0;
//        }, executor).whenComplete((result, exception)->{
//            // whenComplete能得到异常，但是不能修改返回结果
//            System.out.println("得到了结果"+result);
//            System.out.println("抛出的异常"+exception);
//        }).exceptionally(throwable -> {
//            // exceptionally能获取异常，并且能返回结果
//            return 10;
//        });
//        Integer integer = future2.get();
//        System.out.println("返回的结果"+ integer);
//        /**
//         * 方法完成后的处理 handle
//         */
//        CompletableFuture<Integer> future3 = CompletableFuture.supplyAsync(() -> {
//            System.out.println("计算ing");
//            return 10/0;
//        }, executor).handle((value,exception)->{
//            if (exception != null) {
//                System.out.println("方法抛出了异常" + exception);
//                return 10;a
//            } else{
//                System.out.println("方法执行完成");
//                return value;
//            }
//        });
//        Integer value = future3.get();
//        System.out.println("返回的结果"+ integer);

//        // thenRunAsync  串行执行，不能获取上一个任务的执行结果
//        CompletableFuture<Void> future1 = CompletableFuture.runAsync(()->{
//            System.out.println("111");
//        },executor).thenRunAsync(()->{
//            System.out.println("任务2启动");
//        });

        // thenAccept  串行执行,可以获取上一个任务的执行结果，但是没有返回值
//        CompletableFuture<Void> future1 = CompletableFuture.supplyAsync(()->{
//            System.out.println("111");
//            return 111;
//        },executor).thenAcceptAsync((result)-> {
//            System.out.println("上一个任务的返回值" + result);
//            System.out.println("任务2启动");
//        },executor);

        // thenApplyAsync  串行执行,可以获取上一个任务的执行结果，并且有返回值
//        CompletableFuture<Integer> future = CompletableFuture.supplyAsync(()->{
//            System.out.println("111");
//            return 111;
//        },executor).thenApplyAsync((result)-> {
//            System.out.println("上一个任务的返回值" + result);
//            System.out.println("任务2启动");
//            return result * 2;
//        },executor).whenComplete((result,exception)->{
//            System.out.println("最终的返回值"+result);
//        });

        CompletableFuture<Integer> future1 = CompletableFuture.supplyAsync(()->{
            System.out.println("任务1111");
            return 100;
        },executor);
        CompletableFuture<Integer> future2 = CompletableFuture.supplyAsync(()->{
            System.out.println("任务222111");
            return 100;
        },executor);
//        // 1.afterBoth 组合两个任务，不能接收执行结果，也无返回值
//        CompletableFuture<Void> afterBoth = future1.runAfterBothAsync(future2, () -> {
//            System.out.println("两个任务都完成了");
//        }, executor);
//        // 2.thenAcceptBothAsync 组合两个任务，能接收两个任务的执行结果，但是无返回值
//        future1.thenAcceptBothAsync(future2, (result1, result2)->{
//            System.out.println("任务1的返回结果"+result1);
//            System.out.println("任务2的返回结果"+result2);
//        });
//        // 3.thenCombineAsync 组合两个任务，能接收两个任务的执行结果，也有返回值
//        future1.thenCombineAsync(future2, (result1,result2)->{
//            System.out.println("任务1的返回结果"+result1);
//            System.out.println("任务2的返回结果"+result2);
//            return result1 + result2;
//        }).whenComplete((result,exception)->{
//            System.out.println("最终的返回结果"+result);
//        });
        future1.runAfterEitherAsync(future2, ()->{
            System.out.println("有一个任务完成了");
        },executor);
    }
}
